Neural Network Force Field Computational Algorithms For Molecular Dynamics Computer Simulations

ABSTRACT

A computational method for simulating the motion of elements within a multi-element system using a neural network force field (NNFF). The method includes receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system; and predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features, the number of rotationally-covariant features, and the NNFF, to obtain a simulated motion of the elements within the multi-element system.

CROSS-REFERENCE TO RELATED APPLICATIONS Technical Field

This invention relates generally to neural network force field (NNFF) computational algorithms for direct prediction of atomic forces in molecular dynamics computer simulations in material systems, such as electrochemical and water filtration devices.

Background

Molecular dynamics is a computational materials science methodology for simulating the motion of atoms in a material system at real operating pressure and temperature conditions. Methodologies exist to calculate the underlying atomic forces used in the simulation of the motion of atoms. One methodology is the ab-initio quantum mechanics approach. This approach is very accurate but is also very expensive because of the tremendous amount of computational resources necessary to apply the approach. While other approaches exist that consume less computational resources, these other approaches do not deliver as much accuracy.

SUMMARY

In a first embodiment, a computational method for simulating the motion of elements within a multi-element system using a neural network force field (NNFF) is disclosed. The method includes receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system. The method further includes predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features, the number of rotationally-covariant features, and the NNFF, to obtain a simulated motion of the elements within the multi-element system.

In a second embodiment, a non-transitory computer-readable medium tangibly embodying computer readable instructions for a software program is disclosed. The software program is executable by a processor of a computing device to provide operations. The operations include receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system. The operations further include predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features and the number of rotationally-covariant features, and an NNFF, to obtain a simulated motion of the elements within the multi-element system.

In a third embodiment, a computer system for simulating the motion of elements within a multi-element system using an NNFF is disclosed. The computer system includes a simulation computer having a processor for executing computer-readable instructions and a memory for maintaining the computer-executable instructions. The computer-executable instructions when executed by the processor perform the following functions: receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system; and predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features and the number of rotationally-covariant features, and the NNFF, to obtain a simulated motion of the elements within the multi-element system.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 depicts a schematic graph showing the tradeoff between scale and accuracy for different prior art molecular dynamics (MD) force calculation methods.

FIG. 2 is a neural network node schematic diagram of a neural network force field (NNFF) energy prediction scheme under the prior art Behler-Parrinello approach.

FIG. 3 depicts a neural network node schematic of an NNFF algorithm according to one embodiment.

FIG. 4 is a graph of predicted force using an NNFF algorithm of one embodiment versus quantum mechanics calculated force for bulk polyethylene oxide (PEO).

FIG. 5A shows a diagram of a fingerprint neural network (NN) of an NNFF algorithm of one embodiment.

FIGS. 5B, 5C, and 5D depict graphs showing results for the prediction of H, C, and O atoms, respectively, of bulk PEO using the fingerprint NN of the NNFF algorithm of one embodiment.

FIG. 6A shows a diagram of a fingerprint NN and an inversion projection NN combined to produce a combined NN in an NNFF algorithm of one embodiment.

FIGS. 6B, 6C, and 6D depict graphs showing results for the predictions of H, C, and O atoms, respectively, of bulk PEO using the combined NNFF algorithm of one embodiment.

FIG. 7 is a schematic diagram of a computing platform that may be utilized to implement the NNFF algorithms in one or more embodiment, for instance, the NNFF algorithm of FIG. 6 a.

DETAILED DESCRIPTION

As required, detailed embodiments of the present invention are disclosed herein; however, it is to be understood that the disclosed embodiments are merely exemplary of the invention that may be embodied in various and alternative forms. The figures are not necessarily to scale; some features may be exaggerated or minimized to show details of particular components. Therefore, specific structural and functional details disclosed herein are not to be interpreted as limiting, but merely as a representative basis for teaching one skilled in the art to variously employ the present invention.

The term “substantially” may be used herein to describe disclosed or claimed embodiments. The term “substantially” may modify a value or relative characteristic disclosed or claimed in the present disclosure. In such instances, “substantially” may signify that the value or relative characteristic it modifies is within ±0%, 0.1%, 0.5%, 1%, 2%, 3%, 4%, 5% or 10% of the value or relative characteristic.

Molecular dynamics (MDs) methodologies are beneficial for studying physical phenomena, such as, but not limited to, ionic transport, chemical reactions, and material bulk and surface degradation in material systems, such as, devices or functional materials. Non-limiting examples of such material systems include fuel cells, surface coatings, batteries, water desalination, and water filtration. Methodologies exist to calculate the underlying atomic forces used in the simulation of the motion of atoms. The ab-initio quantum mechanics approach is very accurate but is also very expensive because of the tremendous amount of computational resources necessary to apply the approach.

Neural networks have been utilized to fit and predict quantum mechanics energies. These methodologies have been referred to as neural network force fields (NNFF). Derivatives of energy with respect to atomic positions and forces are predicted using quantum mechanics energies. However, these methodologies are also computationally extensive. In light of the foregoing, what is needed is a computational methodology for calculating atomic forces that delivers an adequate level of accuracy while consuming a reasonable amount of computing resources.

Molecular dynamics use atomic positions (and possibly charges, bonds, or other structural information) to calculate interatomic forces of each atom, which are consequently used to modify the velocities of atoms in the simulation. The resulting trajectories of the atoms are utilized to describe physical phenomena, such as, but not limited to ionic transport in batteries and fuel cells, chemical reactions during bulk and surface material degradation, and solid-state material phase change. A tradeoff exists between the accuracy and size (measured by number of atoms and simulated dynamics time) of the simulation depending on the underlying method used to calculate the atomic forces. As set forth above, one accurate but expensive method uses the ab-initio quantum mechanics approach, known as ab-initio molecular dynamics (AIMD).

FIG. 1 depicts schematic graph 100 showing the tradeoff between scale and accuracy for different prior art MD force calculation methods, e.g., AIMD 102, force field MD 104, and coarse-grained MD 106. The y-axis 108 is accuracy and the x-axis 110 is scale (e.g., 100 atoms, 1-10K atoms and 100K atoms). AIMD 102 can be utilized to model anti-stiction coating degradation. Through force field fitting 112, force field MD can be utilized to model amorphous electrolytes and proton-exchange membrane fuel cells (PEMFC) bi polar plate (BPP) oxide coatings. Coarse grained MD 106 can be utilized to model PEMFC nafion polymers.

AIMD is too computationally demanding for many relevant applications. For instance, according to one estimation, an AIMD simulation on a high-performance computer with two hundred (200) cores would take sixty-five (65) years to complete to study the dynamics behavior of amorphous lithium phosphate glass with about five hundred (500) atoms for five hundred (500) nanoseconds.

An alternative to AIMD is classical molecular dynamics. Using this alternative, interatomic forces have been fitted into some closed functional forms to enable several orders of magnitude speedup over AIMD. This alternative approach has been used to simulate large systems, such as polymers and amorphous materials. According to one estimation, the same simulation identified above using the classical molecular dynamics approach finishes in under two (2) days.

One of the drawbacks of the classical molecular dynamics model using pre-defined functional forms is that they restrict the behavior of interatomic interactions within assumptions that remain valid under certain conditions. For example, a classical force field with quadratic functional forms for the bond between atoms assumes that the chemical bond between atoms do not break. This assumption is contrary to the behavior of nature where chemical bonds in molecules form and break during chemical reactions. Relatively more complex pre-assumed functional forms for simulating chemical reactions exist. For example, reactive force fields, such as ReaxFF, is one such model. These models suffer from the disadvantage of being difficult to parametrize and require a large number of relatively complex handcrafted, closed functional forms.

As described above, NNFF algorithms exist that require the computation of quantum mechanics energies. One implementation of NNFF uses rotation-invariant features developed by Behler and Parrinello (otherwise referred to as the Behler-Parrinello approach), as described in the following articles: J. Behler and M. Parrinello, “Generalized Neural-Network Representation of High-Dimensional Potential-Energy Surfaces”, Phys. Rev. Lett. 98, 146401 (2007); M. Gastegger, J. Behler, and P. Marquetand, “Machine Learning Molecular Dynamics for Simulation of Infrared Spectra”, Chem. Sci. 2017, 8, 6924; and J. Behler, “Atom-centered Symmetry Functions for Constructing High-Dimensional Neural Network Potentials”, J. Chem. Phys., 134, 074106 (2011), all of which are incorporated by reference in their entirety herein.

In this implementation, atoms surrounding central atom i within a predefined radius R_(c) are used as inputs into the neural network. Instead of using atomic Cartesian coordinates of the atoms as the input features, the atomic Cartesian coordinates are converted into fingerprint feature vectors. These vectors are invariant under physical operations that should not change the energy coordinates of the local atomic structure. These physical operations include rotation, translation, and purmutation. Rotation-invariance refers to the energy invariance upon rotating the entire Cartesian coordinates of the local atomic environment by an identical rotation with respect to an arbitrary point in space, such as the central atom i. Translational-invariance refers to the energy invariance upon shifting the entire Cartesian coordinates of the local atomic environment by an identical displacement. Permutation-invariance refers to the energy invariance upon changing the ordering sequence of the atoms in the local atomic environment and keeping their positions fixed. In addition to satisfying these three (3) conditions, the chosen fingerprint feature vectors may also satisfy the following criteria (which are assumed to be consistent with the physics of the system): decaying contribution from atoms further away from the central atom i (down to 0 for R>R_(c)); and smoothly varying as the atomic positions vary smoothly in the local atomic environment.

In one implementation, these five (5) requirements are accomplished by converting a list of atomic coordinates surrounding a central atom i {{right arrow over (R_(ι))}} into fingerprint feature vectors {{right arrow over (G_(ι))}} described by two-body and three-body functions. Some non-limiting examples of fingerprint functions are listed below:

$\begin{matrix} {G_{i}^{1} = {\sum\limits_{j}^{\;}{f_{c}\left( R_{ij} \right)}}} & (1) \\ {G_{i}^{2} = {\sum\limits_{j}^{\;}{e^{- {\eta {({R_{ij} - R_{s}})}}^{2}} \cdot {f_{c}\left( R_{ij} \right)}}}} & (2) \\ {G_{i}^{3} = {\sum\limits_{j}^{\;}{{\cos \left( {\kappa \; R_{ij}} \right)} \cdot {f_{c}\left( R_{ij} \right)}}}} & (3) \\ {G_{i}^{4} = {2^{1 - \zeta}{\sum\limits_{j,{k \neq i}}^{all}{\left( {1 + {\lambda \; \cos \; \theta_{ijk}}} \right)^{\zeta} \cdot e^{- {\eta {({R_{ij}^{2} + R_{ii}^{2} + R_{jk}^{2}})}}} \cdot {f_{c}\left( R_{ij} \right)} \cdot {f_{c}\left( R_{ik} \right)} \cdot {f_{c}\left( R_{jk} \right)}}}}} & (4) \\ {G_{i}^{5} = {2^{1 - \zeta}{\sum\limits_{j,{k \neq i}}^{all}{\left( {1 + {\lambda \; \cos \; \theta_{ijk}}} \right)^{\zeta} \cdot e^{- {\eta {({R_{ij}^{2} + R_{ik}^{2}})}}} \cdot {f_{c}\left( R_{ij} \right)} \cdot {f_{c}\left( R_{ik} \right)}}}}} & (5) \end{matrix}$

where η, κ, ζ, and λ are user-defined parameters of G fingerprint functions as described in J. Behler, “Atom-centered Symmetry Functions for Constructing High-Dimensional Neural Network Potentials”, J. Chem. Phys., 134, 074106 (2011). The values of these parameters are typically chosen to appropriately cover the length-scales relevant for the local atomic system under consideration (typically within a cutoff radius R_(c)<10 A). The cutoff function ƒ_(c) depends on R_(c) and can be defined as follows:

$\begin{matrix} {\mspace{20mu} {{f_{c}\left( R_{ij} \right)} = \left\{ \begin{matrix} {0.5 \cdot \left\lbrack {{\cos \left( \frac{\pi \; R_{ij}}{R_{c}} \right)} + 1} \right\rbrack} & {{{for}\mspace{14mu} R_{ij}} \leq R_{c}} \\ 0 & {{{for}\mspace{14mu} R_{ij}} > R_{c}} \end{matrix} \right.}} & (6) \end{matrix}$

The permutation-invariance is only true for atoms of the same elements. For example, exchanging a C atom at position 1 and a C atom at position 2 describes two systems with the same physics, and accordingly, the permutation-invariance holds true. As another example, exchanging a C atom at position 1 and an O atom at position 2 describes two systems with different physics, and permutation-invariance does not hold true. Consequently, when multi-element systems are investigated, the summations in the G functions above should only be done for atoms with the same elements (for two-body G's) or same element-pairs (for three-body G's). Given m number of elements in a MD system of interest surrounding a central atom i, m different G's are calculated for each parameterized 2-body function and m(m+1)/2 different G's for each parametrized three-body function. Due to the construction of these functions (including rotational invariance), these functions provide beneficial representations for learning the rotation-invariant nature of quantum mechanics. However, a machine learning system using these invariant features are limited to use to predict rotation-invariant outputs such as energy.

Many methodologies based on quantum mechanics (e.g., density functional-theory) are used to calculate energy E of a system. However, these methodologies cannot conveniently partition the electronic energy into contributions from individual atoms. Accordingly, in one or more embodiments, {{right arrow over (_(ι))}} feature vectors for each atom in a system are calculated and then utilized to train or predict a single scalar quantity of energy E as shown in FIG. 2. FIG. 2 depicts a neural network node schematic diagram of an NNFF energy prediction scheme under the prior art Behler-Parrinello approach. Atomic coordinate environments R₁ through R_(N) 202 are used as inputs, respectively, of NNFF algorithm 200. Atomic coordinate environments R₁ through R_(N) 202 are used to calculate symmetry functions G₁ through G_(N) 204. Each atomic coordinate environment R₁ through R_(N) 202 are interrelated with each symmetry function G₁ through G_(N) 204. Atomic NNs 206 are trained using symmetry functions G₁ through G_(N) 204 to obtain atomic energies 208, which are used to obtain total energy E 210.

The NNFF approach for AIMD applications suffers from one or more limitations. For instance, during a training cycle, each of the atomic NNs (typically one NN for each element) is co-trained to a single energy quantity E, which is tied to the system of interest. Accordingly, the NNs are co-dependent because each needs to be co-used to predict a single energy value E and are only optimized for predicting the exact MD system used in the training set. There are no independent {{right arrow over (R_(ι))}}→E_(i) samples that can be included for the training of different MD systems containing local atomic environments similar to {{right arrow over (R_(ι))}}. Secondly, during MD runtime (force prediction cycle), expensive calculations are performed to calculate the force vector {right arrow over (F_(ι))} on atom i. {right arrow over (F_(ι))} is the derivative of total system energy E with respect to displacement of a single atom {right arrow over (R_(ι))}. However, prediction of E requires knowing G for all atoms in the MD system {{right arrow over (G₁)}, {right arrow over (G₂)}, . . . , {right arrow over (G_(N))}}. Consequently, calculating {right arrow over (F_(ι))} requires calculating the fingerprint vector 3N times, as shown in the equation below.

$\begin{matrix} \begin{matrix} {F_{k,\alpha} = {{- \frac{\partial E}{\partial R_{k,\alpha}}} = {- {\sum\limits_{i = 1}^{N}\frac{\partial E_{i}}{\partial R_{k,\alpha}}}}}} \\ {= {- {\sum\limits_{i = 1}^{N}{\sum\limits_{j = 1}^{M_{i}}{\frac{\partial E_{i}}{\partial G_{i,j}}\frac{\partial G_{i,j}}{\partial R_{k,\alpha}}}}}}} \end{matrix} & (7) \end{matrix}$

where α indicates the Cartesian x, y, and z axes, Nis the total number of atoms in the MD system, and M_(i) is the total number of fingerprint functions describing atom i. Accordingly, calculating forces for all N atoms in the system grows with O(N²). In certain implementations, certain algorithm modifications can reduce the number of fingerprint vector calculations to 3P times, where P is the average number of atoms in the local atomic environment of the atoms, reducing the computational cost scale to O(N). Nevertheless, this restriction requires 3P {{right arrow over (G_(ι))}} calculations for one {right arrow over (F_(ι))} prediction (P may range from 100 to 400 atoms depending on the chosen R_(c)), as opposed to one {{right arrow over (G_(ι))}} calculation in a direct {right arrow over (F_(ι))} prediction. Accordingly, an NNFF algorithm with direct {right arrow over (F_(ι))} prediction can accelerate NNFF-based MD {right arrow over (F_(ι))} calculations by two (2) to three (3) orders of magnitude.

In one or more embodiments, a computer system configured to implement an algorithm to directly predict quantum mechanics atomic forces from a molecular structure using a neural network without using energy derivatives is disclosed. In certain embodiments, this algorithm may be two (2) to (3) orders of magnitude less computationally demanding (e.g., less computing time of a high-performance computing (HPC) system) compared to known NNFF algorithms requiring the computation of quantum mechanics energies.

The ability of an HPC system to perform certain tasks can be quantified using benchmarks, such as application benchmarks from computational codes, such as those represented in the Standard Performance Evaluation Corporation's SPEC HPC2002 and SPEC MPI2007 suites (www.spec.org/hpg) and in the US National Science Foundation (NSF) HPC system acquisitions process, which are hereby incorporated by reference in their entirety.

In one or more embodiments, simpler functional forms of classical molecular dynamics models are replaced with neural networks. Such networks can be easily tuned according to a supplied [input, output] dataset. Local environment of atoms surrounding an atom i can be used to predict the force experienced by atom i. In a usual NNFF model, center atom i is displaced and then the change in energy contribution from atom i and all other atoms near i are calculated. The numerical derivative of total system energy versus atom i displacement is the atomic force experienced by atom i. This approach is time consuming because the change of energy contribution from all the atoms surrounding atom i need to be calculated to calculate force. In one or more embodiments, systems disclosed herein directly predict the force on atom i. This computational system may be two (2) to three (3) magnitudes faster than the entire system approach because there is no need to calculate additional contribution from other atoms surrounding atom i, while maintaining the requisite accuracy.

In one embodiment, a computational algorithm is disclosed that is configured to directly predict a force vector on an atom by analyzing the local atomic environment surrounding a center atom. A neural network may be trained on rotationally-invariant features of a local atomic environment. The trained neural network is configured to predict the atomic forces within a MD simulation. In one or more embodiments, rotationally-invariant features may be adapted to predict a relatively small number of rotation-invariant intermediate states. Subsequently, a number of rotationally covariant features can be added to these rotationally invariant intermediate states, which then can be used on a later part of the neural network to predict force vector values. The force vector values represent rotationally covariant output.

In one embodiment, because this computational algorithm enables a direct {{right arrow over (R_(ι))}}→{right arrow over (F_(ι))} prediction for each training sample (unlike E prediction which requires knowing all {{right arrow over (R_(ι))}} data samples in the simulation frame), {{right arrow over (R_(ι))}}→{right arrow over (F_(ι))} samples from different sets of systems or materials can be combined for the force field training and/or development. For instance, the computational algorithm of one or more embodiments can be used to develop a force field for a large atomic system of the interface between materials A and B. Using this algorithm, a training set can be created by combining separate smaller structures of material A, material B, and the interface between materials A and B. This training set cannot be created using an algorithm which requires E prediction as part of the routine because the E of the combined large atomistic system is too expensive to calculate from quantum mechanics from a computational standpoint.

The computational algorithm of one or more embodiments may be integrated into an MD simulation engine to perform an MD simulation with accuracy close to that of a significantly more expensive AIMD method. For example, the MD simulation of one or more embodiments may be useful for modeling atom/ion dynamics and chemical reactions relevant for functional materials used in fuel cells, water desalination, catalysis, coatings, and batteries.

In one or more embodiments, the atomic force prediction algorithm of one or more embodiments is integrated into MD software. A non-limiting example of suitable MD software is Large-scale Atomic/Molecular Massively Parallel Simulator (LAMMPS). LAMMPS is available from Sandia National Laboratories, located in Albuquerque, N. Mex. LAMMPS uses a Message Passing Interface (MPI) for parallel communication. LAMMPS is open-source software, distributed under the terms of the GNU General Public License.

A main principle of this algorithm to enable direct force prediction is a definition of a set of k internal axes {{right arrow over (A_(ι))}}={{right arrow over (A_(ι,1))}, {right arrow over (A_(ι,2))}, . . . , {right arrow over (A_(ι,k))}} for each atomic coordinate environment {{right arrow over (R_(ι))}} which rotates with the local atomic environment structure (rotationally-covariant vectors), then projects the rotationally-covariant force vector {right arrow over (F_(ι))} onto {{right arrow over (A_(ι))}} to obtain the internal force vector {right arrow over (F)}_(int,i). Because {right arrow over (F)}_(int,i) is later projected back to the Cartesian coordinate, k is a fixed number and is larger than or equal to 3. Even though both {{right arrow over (A_(ι))}} and {right arrow over (F_(ι))} are rotationally-covariant, these vectors are rigid vectors with respect to the local atomic structure itself (both vectors rotate with the structure). Accordingly, a rotation transformation {circumflex over (T)}∈SO(3) of the atomic positions {{right arrow over (R_(ι))}}→{circumflex over (T)}{{right arrow over (R_(ι))}} correspondingly rotates {right arrow over (F_(ι))}→{circumflex over (T)}{right arrow over (F_(ι))} and {{right arrow over (A_(ι))}}→{circumflex over (T)}{{right arrow over (A_(ι))}}. Consequently, the internal projection vector {right arrow over (F)}_(int,i) is rotationally-invariant. In one or more embodiments, the rotationally-invariant feature vector {{right arrow over (G_(ι))}} is used to predict the rotationally-invariant intermediate state {right arrow over (F)}_(int,i). The rotationally-invariant {right arrow over (F)}_(int,i) and the rotationally-covariant {{right arrow over (A_(ι))}} are used to perform an inverse projection and obtain the rotationally-covariant output Cartesian central atom force {right arrow over (F_(ι))}. A summary of invariant and covariant vector notations is shown in Table 1 below.

TABLE 1 Description Vector Under rotation {circumflex over (T)} ∈ SO(3) Cartesian position of

{circumflex over (T)} 

atomic environment surrounding atom i (out of N) Internal axis number

{circumflex over (T)} 

k (out of at least 3) Cartesian force of

{circumflex over (T)} 

atom i (out of N) Projection of force of F_(int,i,k) = {right arrow over (F)}_(int,i) ·  

  Unchanged atom i (out of N) on internal axis number k (out of at least 3) List of fingerprints

Unchanged centered at atom i

A set of internal axes {{right arrow over (A_(ι))}}={{right arrow over (A_(ι,1))}, {right arrow over (A_(ι,1))}, . . . , {right arrow over (A_(ι,k))}} is defined, where k indicates a group of at least some of the atoms surrounding the central atom i. The criteria for whether an atom j is considered as part of group k or not is user-defined and can be further optimized depending on the MD system under consideration. Once this atom grouping criteria has been determined, the constraint that {right arrow over (A_(ι,k))} should be the weighted average of all the relative position vectors of atoms in the group relative to the central atom i is applied. This constraint can be written mathematically as:

$\begin{matrix} {\overset{}{V_{i,k}} = {\sum\limits_{j \in k}^{\;}{{f_{A,k}\left( R_{ij} \right)} \cdot \overset{}{R_{ij}} \cdot {f_{c}\left( R_{ij} \right)}}}} & (8) \\ {\overset{}{A_{i,k}} = \left\{ \begin{matrix} 0 & {{{for}\mspace{14mu} \overset{}{V_{i,k}}} = 0} \\ {\overset{}{V_{i,k}}/{\overset{}{V_{i,k}}}} & {otherwise} \end{matrix} \right.} & (9) \\ {{f_{c}\left( R_{ij} \right)} = \left\{ \begin{matrix} {0.5 \cdot \left\lbrack {{\cos \left( \frac{\pi \; R_{ij}}{R_{c}} \right)} + 1} \right\rbrack} & {{{for}\mspace{14mu} R_{ij}} \leq R_{c}} \\ 0 & {{{for}\mspace{14mu} R_{ij}} > R_{c}} \end{matrix} \right.} & (10) \end{matrix}$

where ƒ_(A,k) is an axis function as described herein. In one or more embodiments, the same R_(c) for the {right arrow over (A_(ι,k))} calculation as the one for {{right arrow over (G_(ι))}} calculation is set. In other embodiments, more stable {right arrow over (A_(ι,k))} vectors with respect to variation in local atomic coordinates are set because {right arrow over (A_(ι,k))} are only used for vector projection reference axes. The following g_(A) parametrized functional forms are used in place of ƒ_(A,k) for the polyethylene oxide (PEO) polymer (C₂H₄O)_(n):

$\begin{matrix} {{{{g_{A}^{1}\left( R_{ij} \right)} = e^{{- \eta}\; R_{ij}^{2}}},{\eta = 1.0}}{{{g_{A}^{2}\left( R_{ij} \right)} = e^{{- \eta}\; {({R_{ij} - R_{s}})}^{2}}},{\eta = 2.0},{R_{s} = 1.0}}} & (11) \end{matrix}$

In the example of an NNFF development for PEO, the grouping criteria is outlined below in Table 2:

TABLE 2 k Criteria for atom j inclusion in group k Parametrized function for f_(A,k) 1 j is of atomic element C g_(A) ¹ 2 j is of atomic element H g_(A) ¹ 3 j is of atomic element O g_(A) ¹ 4 j is of atomic element C g_(A) ² 5 j is of atomic element H g_(A) ² 6 j is of atomic element O g_(A) ²

Once the way to calculate {{right arrow over (A_(ι))}} from {{right arrow over (R_(ι))}} is defined, {right arrow over (F_(ι))} is projected (using quantum mechanics) onto {{right arrow over (_(ι))}} to find a set of internal force projection {right arrow over (F)}_(int,i). Since both {{right arrow over (G_(ι))}} and {right arrow over (F)}_(int,i) are rotationally-invariant, a first neural network (NN1) can be trained to directly perform the {{right arrow over (G_(ι))}}→{right arrow over (F)}_(int,i) prediction. As the next step, an inverse projection from the internal force {right arrow over (F)}_(int,i) back to the Cartesian atomic force {right arrow over (F_(ι))} is performed. In one embodiment, because the relationship {right arrow over (F)}_(int,i)={{right arrow over (A_(ι))}}{right arrow over (F_(ι))} holds, the inverse projection is performed using a matrix pseudo-inverse relationship to find the least-square-error solution: {right arrow over (F_(ι))}=({{right arrow over (A_(ι))}}^(T){{right arrow over (A_(ι))}})⁻¹{{right arrow over (A_(ι))}}{right arrow over (F)}_(int,i). In practice, this may not give suitable results because the set of internal axes {{right arrow over (A_(ι))}} may not be constrained to be an orthogonal (or close-to-orthogonal) basis for the entire 3D-xyz space. Accordingly, if the basis vectors overlap, small amounts of noise (whether from error or from perturbations of atomic coordinates) can lead to numerical instabilities. While this is not an issue if there is zero error in the {right arrow over (F)}_(int,i) prediction, any error in {right arrow over (F)}_(int,i) prediction by NN1 can be amplified by several orders of magnitude by the pseudo-inverse method during {right arrow over (F_(ι))} calculation. This makes matrix least-squares or pseudo-inversion method unsuitable for doing inverse projection of the force vector in one or more embodiments.

A second, smaller neural network (NN2) may be trained to address the inverse projection problem. {right arrow over (F)}_(int,i) and {{right arrow over (_(ι))}} are used as the inputs to NN2 and NN2 predicts {right arrow over (F_(ι))} as the output. In one or more embodiments, NN2 takes some degree of rotational symmetry into account by performing data augmentation. In one or more embodiments, not only ({right arrow over (F)}_(int,i),{{right arrow over (A_(ι))}})→{right arrow over (F_(ι))} but also ({right arrow over (F)}_(int,i),{circumflex over (T)}{{right arrow over (_(ι))}})→{circumflex over (T)}{right arrow over (F_(ι))} are used as part of the training samples, where {circumflex over (T)} is a random 3D rotation matrix (many different {circumflex over (T)}'s can be used for NN2 data augmentation).

As the next step, NN1 and NN2 may be combined into a single neural network by transferring the weights and biases of NN1 and NN2 into a combined NN architecture with node dimensions identical to NN1 and NN2 (transfer learning). Error of the combined NN may be reduced and/or minimized by running a smaller number of training cycles on the combined network using the ({{right arrow over (G_(ι))}},{{right arrow over (A_(ι))}})→{right arrow over (F_(ι))} training dataset.

The modifications to an NNFF algorithm identified above in one or more embodiments enable force prediction simplification, where rotationally-invariant and rotationally-covariant features are used to enable direct prediction of atomic force on atom i ({right arrow over (F_(ι))}) given just the local atomic environment {{right arrow over (R_(ι))}} coordinates and elements surrounding atom i. FIG. 3 depicts a neural network node schematic of an NNFF algorithm 300 according to one embodiment. Atomic coordinate environments R₁ through R_(N) are used as inputs 302 a through 302 n, respectively, of NNFF algorithm 300. Atomic coordinate environments R₁ through R_(N) are used to calculate symmetry functions G₁ through G_(N) (referred to as symmetry functions 304 a through 304 n of FIG. 3) and axis functions A₁ through A_(N) (referred to as symmetry functions 306 a through 306 n of FIG. 3). First neural network NN1 (referred to as 308 on FIG. 3) is trained using symmetry functions G₁ through G_(N) to obtain internal force vectors F_(int,1) through F_(int,N) (referred to as 310 a through 310 n of FIG. 3). Axis functions A₁ through A_(N) and internal force vectors F_(int,1) through F_(int,N) are used to train second neural network NN2 (referred to as 312 of FIG. 3). The output of NNFF algorithm 300 is atomic forces F₁ through F_(N) (referred to as 314 a through 314 n of FIG. 3) in the cartesian coordinate system. In one or more embodiments, the NNFF algorithm 300 of FIG. 3 has no interdependence between the {{right arrow over (R_(ι))}} training data samples. Accordingly, direct {{right arrow over (_(ι))}}→{right arrow over (F_(ι))} prediction can be performed, which significantly improves computational speed of force prediction.

In one example, a bulk version of polyethylene oxide (PEO) polymer, as shown below, is used to generate a training set of H atoms of PEO using fingerprint {{right arrow over (G_(ι))}} for {right arrow over (F_(ι))} prediction.

FIG. 4 is a graph 400 of |{right arrow over (F_(ι))}| 402 predicted using an NNFF algorithm of one embodiment versus |{right arrow over (F_(ι))}| 404 calculated using a quantum mechanics density functional theory (DFT) simulation. Graph 400 shows the forces on the H atoms for PEO using the two different approaches. The error between the NNFF algorithm and the quantum mechanics DFT simulation can be expressed as Error=(|{right arrow over (F)}_(i,NN)|−|{right arrow over (F)}_(i,QM)|)². Using this expression, the average error is 0.01 (eV/A)², which is within an acceptable range. In this example, no samples from the test set were seen during the training cycle.

FIG. 5A shows diagram 500 of fingerprint neural network (NN) 502 of an NNFF algorithm of one embodiment. Rotation-invariant component 504 of the fingerprint NN corresponds to prediction of the internal force projection intermediate-state {right arrow over (F)}_(int,i) 506. FIGS. 5B, 5C, and 5D depict graphs 508, 510 and 512, respectively, showing results for the prediction of H, C, and O atoms, respectively, in the test set of atomic snapshots taken from bulk PEO using the NNFF algorithm of one embodiment. Using the error equation set forth above, the error between the NNFF algorithm and the quantum mechanics DFT simulation is 0.01 (eV/A)², 0.04 (eV/A)², and 0.16 (eV/A)² for the prediction of H, C, and O atoms, respectively, which is within an acceptable range. In these examples, no samples from the test set were seen during the training cycle.

FIG. 6A shows diagram 600 of fingerprint NN 602 and inversion projection NN 604 combined to produce combined NN 606 in an NNFF algorithm of one embodiment. According to one or more embodiments, weights of NNs 602 and 604 are transferred and the combined NN 606 is retrained. Fingerprint NN 602 is a rotationally-invariant component of the NNFF algorithm and inversion projection NN 604 is a rotationally-covariant component of the NNFF algorithm. Combined NN 606 predicts Cartesian atomic force {right arrow over (F_(ι))}. FIGS. 6B, 6C, and 6D depict graphs 608, 610 and 612, respectively, showing results for the predictions of H, C, and O atoms, respectively, in the test set of atomic snapshots taken from bulk PEO using the NNFF algorithm of one embodiment. {right arrow over (F)}_(i,x|y|z) denotes projection of {right arrow over (F_(ι))} onto the Cartesian x, y, and z axis. Using the error equation set forth above, the error between the NNFF algorithm and the quantum mechanics DFT simulation is 0.03 (eV/A)², 0.58 (eV/A)², and 0.42 (eV/A)² for the prediction of H, C, and O atoms, respectively, which is within an acceptable range. In these examples, no samples from the test set were seen during the training cycle.

The NNFF algorithms and/or methodologies of one or more embodiments are implemented using a computing platform, such as the computing platform 700 illustrated in FIG. 7. The computing platform 700 may include a processor 702, memory 704, and non-volatile storage 706. The processor 702 may include one or more devices selected from high-performance computing (HPC) systems including high-performance cores, microprocessors, micro-controllers, digital signal processors, microcomputers, central processing units, field programmable gate arrays, programmable logic devices, state machines, logic circuits, analog circuits, digital circuits, or any other devices that manipulate signals (analog or digital) based on computer-executable instructions residing in memory 704. The memory 704 may include a single memory device or a number of memory devices including, but not limited to, random access memory (RAM), volatile memory, non-volatile memory, static random access memory (SRAM), dynamic random access memory (DRAM), flash memory, cache memory, or any other device capable of storing information. The non-volatile storage 706 may include one or more persistent data storage devices such as a hard drive, optical drive, tape drive, non-volatile solid state device, cloud storage or any other device capable of persistently storing information.

The processor 702 may be configured to read into memory 704 and execute computer-executable instructions residing in NNFF software module 708 of the non-volatile storage 706 and embodying NNFF algorithms and/or methodologies of one or more embodiments. The processor 702 may be further configured to read into memory 704 and execute computer-executable instructions residing in MD software module 710 (such as LAMMPS) of the non-volatile storage 706 and embodying MD algorithms and/or methodologies. The software modules 708 and 710 may include operating systems and applications. The software modules 708 and 710 may be compiled or interpreted from computer programs created using a variety of programming languages and/or technologies, including, without limitation, and either alone or in combination, Java, C, C++, C#, Objective C, Fortran, Pascal, Java Script, Python, Perl, and PL/SQL.

Upon execution by the processor 702, the computer-executable instructions of the NNFF software module 708 and the MD software module 710 may cause the computing platform 700 to implement one or more of the NNFF algorithms and/or methodologies and MD algorithms and/or methodologies, respectively, disclosed herein. The non-volatile storage 706 may also include NNFF data 712 and MD data 714 supporting the functions, features, and processes of the one or more embodiments described herein.

The program code embodying the algorithms and/or methodologies described herein is capable of being individually or collectively distributed as a program product in a variety of different forms. The program code may be distributed using a computer readable storage medium having computer readable program instructions thereon for causing a processor to carry out aspects of one or more embodiments. Computer readable storage media, which is inherently non-transitory, may include volatile and non-volatile, and removable and non-removable tangible media implemented in any method or technology for storage of information, such as computer-readable instructions, data structures, program modules, or other data. Computer readable storage media may further include RAM, ROM, erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other solid state memory technology, portable compact disc read-only memory (CD-ROM), or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store the desired information and which can be read by a computer. Computer readable program instructions may be downloaded to a computer, another type of programmable data processing apparatus, or another device from a computer readable storage medium or to an external computer or external storage device via a network.

Computer readable program instructions stored in a computer readable medium may be used to direct a computer, other types of programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions that implement the functions, acts, and/or operations specified in the flowcharts or diagrams. In certain alternative embodiments, the functions, acts, and/or operations specified in the flowcharts and diagrams may be re-ordered, processed serially, and/or processed concurrently consistent with one or more embodiments. Moreover, any of the flowcharts and/or diagrams may include more or fewer nodes or blocks than those illustrated consistent with one or more embodiments.

While all of the invention has been illustrated by a description of various embodiments and while these embodiments have been described in considerable detail, it is not the intention of the applicant to restrict or in any way limit the scope of the appended claims to such detail. Additional advantages and modifications will readily appear to those skilled in the art. The invention in its broader aspects is therefore not limited to the specific details, representative apparatus and method, and illustrative examples shown and described. Accordingly, departures may be made from such details without departing from the spirit or scope of the general inventive concept. 

What is claimed is:
 1. A computational method for simulating the motion of elements within a multi-element system using a neural network force field (NNFF), the method comprising: receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system; and predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features and the number of rotationally-covariant features, and the NNFF, to obtain a simulated motion of the elements within the multi-element system.
 2. The computational method of claim 1, further comprising training a first neural network (NN1) based on the number of rotationally-invariant features to predict a number of rotationally-invariant intermediate states.
 3. The computational method of claim 2, further comprising training a second neural network (NN2) based on the number of rotationally-invariant intermediate states and the number of rotationally-covariant features to predict a number of rotationally-covariant outputs.
 4. The computational method of claim 3, further comprising concentrating NN1 and NN2 into a third neural network (NN3) used to obtain the simulated motion of the elements within the multi-element system.
 5. The computational method of claim 4, wherein the multi-element system is a material system, the elements are atoms within the material system, and the local environment is an atomic local environment.
 6. The computational method of claim 5, wherein the number of rotationally-covariant features include a set of internal axes {{right arrow over (A_(ι))}}.
 7. The computational method of claim 6, wherein the number of rotationally-invariant intermediate states includes a scalar projection of an atomic force experienced by a center atom i ({right arrow over (F_(ι))}) to the set of internal axes {{right arrow over (A_(ι))}}.
 8. The computational method of claim 7, wherein the number of rotationally-covariant output includes a set of Cartesian components of the atomic force experiences by the center atom i ({right arrow over (F_(ι))}).
 9. The computational method of claim 1, wherein the number of rotationally-invariant features include one or more Behler-Parrinello type fingerprint feature vectors.
 10. The computational method of claim 1, wherein the multi-element system is a portion of one of the following systems: fuel cell, water desalination, catalysis, coating, and battery.
 11. A non-transitory computer-readable medium tangibly embodying computer readable instructions for a software program, the software program being executable by a processor of a computing device to provide operations comprising: receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of a multi-element system having elements; and predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features and the number of rotationally-covariant features, and a neural network force field (NNFF), to obtain a simulated motion of the elements within the multi-element system.
 12. The non-transitory computer-readable medium of claim 11, wherein the software program is executable by the processor of the computing device to provide the further operation of training a first neural network (NN1) based on the number of rotationally-invariant features to predict a number of rotationally-invariant intermediate states.
 13. The non-transitory computer-readable medium of claim 12, wherein the software program is executable by the processor of the computing device to provide the further operation of training a second neural network (NN2) based on the number of rotationally-invariant intermediate states and the number of rotationally-covariant features to predict a number of rotationally-covariant outputs.
 14. The non-transitory computer-readable medium of claim 13, wherein the software program is executable by the processor of the computing device to provide the further operation of concentrating NN1 and NN2 into a third neural network (NN3) used to obtain the simulated motion of the elements within the multi-element system.
 15. The non-transitory computer-readable medium of claim 11, wherein the number of rotationally-invariant features include one or more Behler-Parrinello type fingerprint feature vectors.
 16. A computer system for simulating the motion of elements within a multi-element system using a neural network force field (NNFF) including a simulation computer having a processor for executing computer-readable instructions and a memory for maintaining the computer-executable instructions, the computer-executable instructions when executed by the processor perform the following functions: receiving a combination of a number of rotationally-invariant features and a number of rotationally-covariant features of a local environment of the multi-element system having elements; and predicting a force vector for each element within the multi-element system based on the combination of the number of rotationally-invariant features and the number of rotationally-covariant features, and the NNFF, to obtain a simulated motion of the elements within the multi-element system.
 17. The computer system of claim 16, wherein the computer-executable instructions when executed by the processor performs the further function of training a first neural network (NN1) based on the number of rotationally-invariant features to predict a number of rotationally-invariant intermediate states.
 18. The computer system of claim 17, wherein the computer-executable instructions when executed by the processor performs the further function of training a second neural network (NN2) based on the number of rotationally-invariant intermediate states and the number of rotationally-covariant features to predict a number of rotationally-covariant outputs.
 19. The computer system of claim 18, wherein the computer-executable instructions when executed by the processor performs the further function of concentrating NN1 and NN2 into a third neural network (NN3) used to obtain the simulated motion of the elements within the multi-element system.
 20. The computer system of claim 16, wherein the number of rotationally-invariant features include one or more Behler-Parrinello type fingerprint feature vectors. 